package com.webull.information.center.validator;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.webull.information.center.common.constants.CenterCode;
import com.webull.information.center.common.util.CenterExceptionUtil;

/**
 * @author chengang
 * @version 1.0
 * @date 16-5-17
 * @time 下午12:20
 * @since JDK 1.8
 */
public abstract class BaseValidator {
	protected final Logger log = LogManager.getLogger(getClass());

	/**
	 * 判断id以,分隔的字符串准确性,例如(1,23,424234)
	 * 
	 * @param ids
	 * @since 0.1.0
	 */
	public void validatorIdsWithComma(String ids) {
		String regex = "^[0-9]{1,}[,[0-9]{1,}]*";
		if (!ids.matches(regex)) {
			throw CenterExceptionUtil.createCenterException(CenterCode.PARAM_NULL);
		}
	}

	/**
	 * 验证用户提交的id串数据是否符合规则 规则：id列表一次性提交不超过10个
	 *
	 * @param ids
	 *            用户提交的id串
	 */
	public void validateSearchByIds(Integer[] ids) {
		validateObjectIsNull(ids, CenterCode.IDS_NULL);
		if (ids.length > 2000) {
			log.error("id串长度超限，ids={}", ids);
			throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
		}
		if (ids.length == 0) {
			log.error("id列表不能为空数组,ids={}", ids);
			throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
		}
		for (Integer id : ids) {
			if (id == null || id < 0) {
				log.error("id串不合法，ids={}", ids);
				throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
			}
		}
	}

	/**
	 * 验证用户提交的id串数据是否符合规则 规则：id列表一次性提交不超过10个
	 *
	 * @param ids
	 *            用户提交的id串
	 */
	public void validateSearchByLongIds(Long[] ids) {
		validateObjectIsNull(ids, CenterCode.IDS_NULL);
		if (ids.length > 2000) {
			log.error("id串长度超限，ids={}", ids);
			throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
		}
		if (ids.length == 0) {
			log.error("id列表不能为空数组,ids={}", ids);
			throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
		}
		for (Long id : ids) {
			if (id < 0) {
				log.error("id串不合法，ids={}", ids);
				throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
			}
		}
	}

	/**
	 * 验证用户提交的id数据是否符合规则 规则：id不能为空且不能小于等于0
	 *
	 * @param id
	 *            用户提交的id
	 */
	public void validateGetById(Integer id) {
		validateIdIsNull(id, CenterCode.PARAM_NULL);
		validateIdIsError(id, CenterCode.PARAM_ERROR);
	}

	/**
	 * 验证用户提交的id数据是否符合规则 规则：id不能为空且不能小于等于0
	 *
	 * @param id
	 *            用户提交的id
	 */
	public void validateGetByLongId(Long id) {
		validateLongTypeIdIsNull(id, CenterCode.PARAM_NULL);
		validateLongTypeIdIsError(id, CenterCode.PARAM_ERROR);
	}

	/**
	 * 验证日期类型是否符合格式
	 */
	protected Date validateDateTypeIsError(String date, String format, String code) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			java.util.Date date_util = sdf.parse(date);
			return date_util;
		} catch (Exception e) {
			log.error("date类型错误,date={},format={}", date, format);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证日期类型是否符合格式
	 */
	protected Date validateDateTypeIsError(Date date, String format, String code, String remarkMsg) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			java.util.Date date_util = sdf.parse(sdf.format(date));
			return date_util;
		} catch (Exception e) {
			log.error("date类型错误,date={},format={}", date, format);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证Integer类型是否合法
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateIntegerTypeIsError(Integer number, String code) {
		if (number < 0) {
			log.error("整型类型错误,number={},code={}", number, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证Integer类型是否合法
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateIntegerTypeIsError(Integer number, String code, String remarkMsg) {
		if (number < 0) {
			log.error("整型类型错误,number={},code={},remarkMsg={}", number, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证Integer类型
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateIntegerTypeIsNull(Integer number, String code, String remarkMsg) {
		if (number == null) {
			log.error("整型类型不能为空,number={},code={},remarkMsg={}", number, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证Integer类型
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateIntegerTypeIsNull(Integer number, String code) {
		if (number == null) {
			log.error("整型类型不能为空,number={},code={}", number, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证Long类型是否合法
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateLongTypeIsError(Long number, String code, String remarkMsg) {
		if (number < 0) {
			log.error("长整型类型错误,number={},code={}", number, code);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证Long类型
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateLongTypeIsNull(Long number, String code) {
		if (number == null) {
			log.error("长整型类型不能为空,number={},errorCode={}", number, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证Long类型
	 *
	 * @param number
	 *            待验证的数据
	 * @param code
	 *            错误码
	 */
	protected void validateLongTypeIsNull(Long number, String code, String remarkMsg) {
		if (number == null) {
			log.error("长整型类型不能为空,number={},remarkMsg={},errorCode={}", number, remarkMsg, code);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证对象是否为空
	 *
	 * @param object
	 *            对象
	 * @param code
	 *            错误码
	 */
	protected void validateObjectIsNull(Object object, String code) {
		if (object == null) {
			log.error("对象不能为空,object={},code={}", object, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证对象是否为空
	 *
	 * @param object
	 *            对象
	 * @param code
	 *            错误码
	 */
	protected void validateObjectIsNull(Object object, String code, String remarkMsg) {
		if (object == null) {
			log.error("对象不能为空,object={},code={},remarkMsg={}", object, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证id是否为空
	 *
	 * @param id
	 *            待验证的id
	 * @param code
	 *            错误码
	 */
	protected void validateIdIsNull(Integer id, String code) {
		if (id == null) {
			log.error("id不能为空，id={},code={}", id, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id是否为空
	 *
	 * @param id
	 *            待验证的id
	 * @param code
	 *            错误码
	 */
	protected void validateLongTypeIdIsNull(Long id, String code) {
		if (id == null) {
			log.error("id不能为空，id={},code={}", id, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id是否格式正确
	 *
	 * @param id
	 *            待验证的id
	 * @param code
	 *            错误码
	 */
	protected void validateIdIsError(Integer id, String code) {
		if (id <= 0) {
			log.error("id格式不正确，id={},code={}", id, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id是否格式正确
	 *
	 * @param id
	 *            待验证的id
	 * @param code
	 *            错误码
	 */
	protected void validateLongTypeIdIsError(Long id, String code) {
		if (id <= 0) {
			log.error("id格式不正确，id={},code={}", id, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id串是否为空
	 *
	 * @param ids
	 *            待验证的id串
	 * @param code
	 *            错误码
	 */
	protected void validateIdListStrIsNull(String ids, String code) {
		if (ids == null) {
			log.error("id串不能为空，ids={},code={}", ids, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id串是否为空
	 *
	 * @param ids
	 *            待验证的id串
	 * @param code
	 *            错误码
	 */
	protected void validateIdListStrIsNull(String ids, String code, String remarkMsg) {
		if (ids == null) {
			log.error("id串不能为空，ids={},code={}", ids, code);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证id串是否格式正确
	 *
	 * @param ids
	 *            待验证的id串
	 * @param code
	 *            错误码
	 */
	protected void validateIdListStrIsError(String ids, String code) {
		if (ids.trim().equals("")) {
			log.error("id串格式不正确，ids={},code={}", ids, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证id串是否格式正确
	 *
	 * @param ids
	 *            待验证的id串
	 * @param code
	 *            错误码
	 */
	protected void validateIdListStrIsError(String ids, String code, String remarkMsg) {
		if (ids.trim().equals("")) {
			log.error("id串格式不正确，ids={},code={},remarkMsg={}", ids, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证字符串类型是否合法
	 *
	 * @param str
	 *            待验证的字符串
	 * @param code
	 *            错误码
	 */
	protected void validateStrTypeIsError(String str, String code) {
		if (str.trim().equals("") || str.length() == 0) {
			log.error("字符串类型不合法,str={},code={}", str, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证字符串类型是否合法
	 *
	 * @param str
	 *            待验证的字符串
	 * @param code
	 *            错误码
	 * @param remarkMsg
	 *            扩展字符串
	 */
	protected void validateStrTypeIsError(String str, String code, String remarkMsg) {
		if (str.trim().equals("") || str.length() == 0) {
			log.error("字符串类型不合法,str={},code={},remarkMsg={}", str, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证字符串长度是否超限
	 *
	 * @param str
	 *            待验证的字符串
	 * @param limit
	 *            长度限制
	 * @param code
	 *            错误码
	 */
	protected void validateStrTypeOverLimit(String str, int limit, String code) {
		if (str.length() > limit) {
			log.error("字符串类型长度超限,str={},最大为{}个字符,code={}", str, limit, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证字符串长度是否超限
	 *
	 * @param str
	 *            待验证的字符串
	 * @param limit
	 *            长度限制
	 * @param code
	 *            错误码
	 * @param remarkMsg
	 *            扩展字符串
	 */
	protected void validateStrTypeOverLimit(String str, int limit, String code, String remarkMsg) {
		if (str.length() > limit) {
			log.error("字符串类型长度超限，str={},最大为{}个字符,code={},remarkMsg={}", str, limit, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证业务类型是否超过限制
	 *
	 * @param type
	 *            业务类型数据
	 * @param min
	 *            最小范围
	 * @param max
	 *            最大范围
	 * @param code
	 *            错误码
	 * @param remarkMsg
	 *            扩展字符串
	 */
	protected void validateBusTypeOverLimit(Integer type, int min, int max, String code, String remarkMsg) {
		if (type < min || type > max) {
			log.error("业务类型超过限制,type={},min={},max={},code={},remarkMsg={}" + type, min, max, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证字符串类型
	 *
	 * @param str
	 *            待验证的字符串
	 * @param code
	 *            错误码
	 */
	protected void validateStrTypeIsNull(String str, String code) {
		if (str == null || StringUtils.isBlank(str)) {
			log.error("字符串类型不能为空,str={},code={}", str, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证字符串类型
	 *
	 * @param str
	 *            待验证的字符串
	 * @param code
	 *            错误码
	 */
	protected void validateLangIsError(String str, String code) {
		if (str == null || StringUtils.isBlank(str)) {
			log.error("语言类型不能为空,str={},code={}", str, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
		if (!ArrayUtils.contains(new String[] { "zh", "en", "zhHant", "zh_hant", "zh-hant" }, str)) {
			log.error("语言类型不正确,str={},code={}", str, code);
			throw CenterExceptionUtil.createCenterException(code);
		}
	}

	/**
	 * 验证字符串类型
	 *
	 * @param str
	 *            待验证的字符串
	 * @param code
	 *            错误码
	 */
	protected void validateStrTypeIsNull(String str, String code, String remarkMsg) {
		if (str == null || StringUtils.isBlank(str)) {
			log.error("字符串类型不能为空,str={},code={},remarkMsg={}", str, code, remarkMsg);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证bigdecimal类型不能为空
	 *
	 * @param decimal
	 *            数据类型
	 * @param code
	 *            错误码
	 */
	protected void validateBigDecimalTypeIsNull(BigDecimal decimal, String code, String remarkMsg) {
		if (decimal == null) {
			log.error("bigdecimal类型不能为空,decimal={},remarkMsg={},errorCode={}", decimal, remarkMsg, code);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证bigdecimal类型不合法
	 *
	 * @param decimal
	 *            数据类型
	 * @param code
	 *            错误码
	 */
	protected void validateBigDecimalTypeIsError(BigDecimal decimal, String code, String remarkMsg) {
		if (decimal.longValue() <= 0) {
			log.error("bigdecimal类型错误,decimal={},remarkMsg={},errorCode={}", decimal, remarkMsg, code);
			throw CenterExceptionUtil.createCenterException(code, remarkMsg);
		}
	}

	/**
	 * 验证id列表的格式是否正确,长度是否超过10个
	 *
	 * @param ids
	 *            品牌id串
	 * @return 品牌id列表
	 */
	protected void validateIdsType(String ids) {
		String[] strs = ids.split(",");
		if (strs.length > 10) {
			log.error("id串长度超限，ids={}", ids);
			throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
		}
		for (String idStr : strs) {
			try {
				Integer tempId = Integer.parseInt(idStr);
				if (tempId < 0) {
					log.error("id串不合法，ids={}", idStr);
					throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
				}
			} catch (NumberFormatException e) {
				log.error("id串数据转换异常,id={}", idStr, e);
				throw CenterExceptionUtil.createCenterException(CenterCode.IDS_ERROR);
			}
		}
	}

	/**
	 * 验证批量查询条件不能全部为空
	 *
	 * @param paraMap
	 *            批量查询条件
	 */
	protected void validateSearchParam(Map<String, Object> paraMap) {
		Collection collection = paraMap.values();
		Iterator it = collection.iterator();
		boolean temp = true;
		for (; it.hasNext();) {
			Object ob = it.next();
			if (ob != null) {
				temp = false;
				break;
			}
		}
		if (temp) {
			log.error("查询条件不能为空");
			throw CenterExceptionUtil.createCenterException(CenterCode.PARAM_NULL);
		}
	}

}
